home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / sviluppo / svilupp2 / amphn192.lha / src / phonerexx_rxif.c < prev    next >
C/C++ Source or Header  |  1996-11-16  |  23KB  |  959 lines
  1. /*
  2.  * Source generated with ARexxBox 1.12 (May 18 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  */
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include <dos/dos.h>
  9. #include <rexx/storage.h>
  10. #include <rexx/rxslib.h>
  11.  
  12. #ifdef __GNUC__
  13. /* GCC needs all struct defs */
  14. #include <dos/exall.h>
  15. #include <graphics/graphint.h>
  16. #include <intuition/classes.h>
  17. #include <devices/keymap.h>
  18. #include <exec/semaphores.h>
  19. #endif
  20.  
  21. #include <clib/alib_protos.h>
  22. #include <clib/exec_protos.h>
  23. #include <clib/dos_protos.h>
  24. #include <clib/rexxsyslib_protos.h>
  25.  
  26. #ifndef __NO_PRAGMAS
  27.  
  28. #ifdef AZTEC_C
  29. #include <pragmas/exec_lib.h>
  30. #include <pragmas/dos_lib.h>
  31. #include <pragmas/rexxsyslib_lib.h>
  32. #endif
  33.  
  34. #ifdef LATTICE
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/dos_pragmas.h>
  37. #include <pragmas/rexxsyslib_pragmas.h>
  38. #endif
  39.  
  40. #endif /* __NO_PRAGMAS */
  41.  
  42. #include <stdlib.h>
  43. #include <stdio.h>
  44. #include <string.h>
  45. #include <ctype.h>
  46.  
  47. #ifdef LATTICE
  48. #undef toupper
  49. #define inline __inline
  50. #endif
  51.  
  52. #ifdef __GNUC__
  53. #undef toupper
  54. static inline char toupper( char c )
  55. {
  56.     return( islower(c) ? c - 'a' + 'A' : c );
  57. }
  58. #endif
  59.  
  60. #ifdef AZTEC_C
  61. #define inline
  62. #endif
  63.  
  64. #include "phonerexx.h"
  65. #include "phonerexx_aux.h"
  66.  
  67. extern struct ExecBase *SysBase;
  68. extern struct DosLibrary *DOSBase;
  69. extern struct RxsLib *RexxSysBase;
  70.  
  71.  
  72. /* $ARB: I 831931909 */
  73.  
  74.  
  75. /* $ARB: B 1 QUIT */
  76. void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
  77. {
  78.     struct rxd_quit *rd = *rxd;
  79.  
  80.     switch( action )
  81.     {
  82.         case RXIF_INIT:
  83.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  84.             break;
  85.             
  86.         case RXIF_ACTION:
  87.             /* Insert your CODE here */
  88.             FakeIDCMPMessage(IDCMP_MENUPICK, P_QUIT, 0);
  89.             rd->rc = 1;
  90.             break;
  91.         
  92.         case RXIF_FREE:
  93.             /* FREE your local data here */
  94.             FreeVec( rd );
  95.             break;
  96.     }
  97.     return;
  98. }
  99. /* $ARB: E 1 QUIT */
  100.  
  101. /* $ARB: B 2 CONNECT */
  102. void rx_connect( struct RexxHost *host, struct rxd_connect **rxd, long action, struct RexxMsg *rexxmsg )
  103. {
  104.     struct rxd_connect *rd = *rxd;
  105.  
  106.     switch( action )
  107.     {
  108.         case RXIF_INIT:
  109.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  110.             if( rd = *rxd )
  111.             {
  112.                 /* set your DEFAULTS here */
  113.             }
  114.             break;
  115.             
  116.         case RXIF_ACTION:
  117.             /* Insert your CODE here */
  118.             if ((rd->arg.force)&&(BNetConnect)) ClosePhoneSocket();
  119.             rd->rc = ConnectPhoneSocket((rd->arg.prompt!=0),rd->arg.hostname ? rd->arg.hostname : "");
  120.             break;
  121.         
  122.         case RXIF_FREE:
  123.             /* FREE your local data here */
  124.             FreeVec( rd );
  125.             break;
  126.     }
  127.     return;
  128. }
  129. /* $ARB: E 2 CONNECT */
  130.  
  131. /* $ARB: B 3 DISCONNECT */
  132. void rx_disconnect( struct RexxHost *host, struct rxd_disconnect **rxd, long action, struct RexxMsg *rexxmsg )
  133. {
  134.     struct rxd_disconnect *rd = *rxd;
  135.     
  136.     switch( action )
  137.     {
  138.         case RXIF_INIT:
  139.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  140.             break;
  141.             
  142.         case RXIF_ACTION:
  143.             /* Insert your CODE here */
  144.             rd->rc = 0;
  145.             if (BNetConnect)
  146.             {
  147.                 ClosePhoneSocket();
  148.                 rd->rc = 1;
  149.             }
  150.             break;
  151.         
  152.         case RXIF_FREE:
  153.             /* FREE your local data here */
  154.             FreeVec( rd );
  155.             break;
  156.     }
  157.     return;
  158. }
  159. /* $ARB: E 3 DISCONNECT */
  160.  
  161. /* $ARB: B 4 CONNECTTO */
  162. void rx_connectto( struct RexxHost *host, struct rxd_connectto **rxd, long action, struct RexxMsg *rexxmsg )
  163. {
  164.     struct rxd_connectto *rd = *rxd;
  165.     char szPierName[MAXPEERNAMELENGTH];
  166.  
  167.     switch( action )
  168.     {
  169.         case RXIF_INIT:
  170.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  171.             if( rd = *rxd )
  172.             {
  173.                 /* set your DEFAULTS here */
  174.             }
  175.             break;
  176.             
  177.         case RXIF_ACTION:
  178.             /* Insert your CODE here */
  179.             rd->rc = 0;
  180.             
  181.             /* adjust menu order to array order */
  182.             if (rd->arg.entry)
  183.             {
  184.                 (*rd->arg.entry)--; if (*rd->arg.entry < 0) *rd->arg.entry = 9;            
  185.                 if ((*rd->arg.entry >= 0)&&(*rd->arg.entry <= 9)&&(pszCallIPs[*rd->arg.entry]))
  186.                 {
  187.                     if ((rd->arg.force)&&(BNetConnect)) ClosePhoneSocket();
  188.                     Strncpy(szPierName,pszCallIPs[*rd->arg.entry],MAXPEERNAMELENGTH);
  189.                     rd->rc = ConnectPhoneSocket((rd->arg.prompt!=0),szPierName);
  190.                 }
  191.             }
  192.             break;
  193.         
  194.         case RXIF_FREE:
  195.             /* FREE your local data here */
  196.             FreeVec( rd );
  197.             break;
  198.     }
  199.     return;
  200. }
  201. /* $ARB: E 4 CONNECTTO */
  202.  
  203. /* $ARB: B 5 PLAYFILE */
  204. void rx_playfile( struct RexxHost *host, struct rxd_playfile **rxd, long action, struct RexxMsg *rexxmsg )
  205. {
  206.     struct rxd_playfile *rd = *rxd;
  207.     FILE * fpTest;
  208.     
  209.     switch( action )
  210.     {
  211.         case RXIF_INIT:
  212.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  213.             if( rd = *rxd )
  214.             {
  215.                 /* set your DEFAULTS here */
  216.             }
  217.             break;
  218.             
  219.         case RXIF_ACTION:
  220.             /* Insert your CODE here */
  221.             rd->rc = 0;
  222.             if ((rd->arg.filename)&&(fpTest = fopen(rd->arg.filename, "rb")))
  223.             {
  224.                 fclose(fpTest);
  225.                 StartSoundPlayer(rd->arg.filename);
  226.                 rd->rc = 1;
  227.             }
  228.             break;
  229.         
  230.         case RXIF_FREE:
  231.             /* FREE your local data here */
  232.             FreeVec( rd );
  233.             break;
  234.     }
  235.     return;
  236. }
  237. /* $ARB: E 5 PLAYFILE */
  238.  
  239. /* $ARB: B 6 MEMO */
  240. void rx_memo( struct RexxHost *host, struct rxd_memo **rxd, long action, struct RexxMsg *rexxmsg )
  241. {
  242.     struct rxd_memo *rd = *rxd;
  243.  
  244.     switch( action )
  245.     {
  246.         case RXIF_INIT:
  247.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  248.             if( rd = *rxd )
  249.             {
  250.                 /* set your DEFAULTS here */
  251.             }
  252.             break;
  253.             
  254.         case RXIF_ACTION:
  255.             /* Insert your CODE here */
  256.             if ((rd->arg.start)||(rd->arg.stop))
  257.                  rd->rc = StartRecording((rd->arg.start != 0), rd->arg.filename);
  258.             else rd->rc = StartRecording((fpMemo == NULL), rd->arg.filename);
  259.             break;
  260.         
  261.         case RXIF_FREE:
  262.             /* FREE your local data here */
  263.             FreeVec( rd );
  264.             break;
  265.     }
  266.     return;
  267. }
  268. /* $ARB: E 6 MEMO */
  269.  
  270. /* $ARB: B 7 SETSAMPLER */
  271. void rx_setsampler( struct RexxHost *host, struct rxd_setsampler **rxd, long action, struct RexxMsg *rexxmsg )
  272. {
  273.     struct rxd_setsampler *rd = *rxd;
  274.     int nWanted = SAMPLER_MAX;
  275.     
  276.     switch( action )
  277.     {
  278.         case RXIF_INIT:
  279.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  280.             if( rd = *rxd )
  281.             {
  282.                 /* set your DEFAULTS here */
  283.             }
  284.             break;
  285.             
  286.         case RXIF_ACTION:
  287.             /* Insert your CODE here */
  288.                        if (rd->arg.dss8)       nWanted = SAMPLER_GVPDSS8;
  289.                        if (rd->arg.perfectsound) nWanted = SAMPLER_PERFECT;
  290.                        if (rd->arg.amas)       nWanted = SAMPLER_AMAS;
  291.                        if (rd->arg.soundmagic)   nWanted = SAMPLER_SOMAGIC;
  292.                        if (rd->arg.toccata)      nWanted = SAMPLER_TOCCATA;
  293.                        if (rd->arg.aura)       nWanted = SAMPLER_AURA;
  294.                        if (rd->arg.ahi)       nWanted = SAMPLER_AHI;
  295.                        if (rd->arg.custom)       nWanted = SAMPLER_CUSTOM;
  296.                        if (rd->arg.generic)       nWanted = SAMPLER_GENERIC;
  297.                        ChangeSamplerType(nWanted);
  298.                        rd->rc = (nWanted == ubSamplerType);
  299.             break;
  300.         
  301.         case RXIF_FREE:
  302.             /* FREE your local data here */
  303.             FreeVec( rd );
  304.             break;
  305.     }
  306.     return;
  307. }
  308. /* $ARB: E 7 SETSAMPLER */
  309.  
  310. /* $ARB: B 8 SETCOMPRESSION */
  311. void rx_setcompression( struct RexxHost *host, struct rxd_setcompression **rxd, long action, struct RexxMsg *rexxmsg )
  312. {
  313.     struct rxd_setcompression *rd = *rxd;
  314.  
  315.     switch( action )
  316.     {
  317.         case RXIF_INIT:
  318.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  319.             if( rd = *rxd )
  320.             {
  321.                 /* set your DEFAULTS here */
  322.             }
  323.             break;
  324.             
  325.         case RXIF_ACTION:
  326.             /* Insert your CODE here */
  327.             if (rd->arg.adpcm2) ChangeCompressMode(COMPRESS_ADPCM2);
  328.             if (rd->arg.adpcm3) ChangeCompressMode(COMPRESS_ADPCM3);
  329.             if (rd->arg.none)   ChangeCompressMode(COMPRESS_NONE);
  330.             rd->rc = rd->arg.adpcm2 || rd->arg.adpcm3 || rd->arg.none;
  331.             break;
  332.         
  333.         case RXIF_FREE:
  334.             /* FREE your local data here */
  335.             FreeVec( rd );
  336.             break;
  337.     }
  338.     return;
  339. }
  340. /* $ARB: E 8 SETCOMPRESSION */
  341.  
  342. /* $ARB: B 9 SETXMITENABLE */
  343. void rx_setxmitenable( struct RexxHost *host, struct rxd_setxmitenable **rxd, long action, struct RexxMsg *rexxmsg )
  344. {
  345.     struct rxd_setxmitenable *rd = *rxd;
  346.  
  347.     switch( action )
  348.     {
  349.         case RXIF_INIT:
  350.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  351.             if( rd = *rxd )
  352.             {
  353.                 /* set your DEFAULTS here */
  354.             }
  355.             break;
  356.             
  357.         case RXIF_ACTION:
  358.             /* Insert your CODE here */
  359.             if (rd->arg.toggle) nToggleMode = TOGGLE_TOGGLE;
  360.             if (rd->arg.hold)   nToggleMode = TOGGLE_HOLD;
  361.             rd->rc = (rd->arg.toggle || rd->arg.hold);
  362.             break;
  363.         
  364.         case RXIF_FREE:
  365.             /* FREE your local data here */
  366.             FreeVec( rd );
  367.             break;
  368.     }
  369.     return;
  370. }
  371. /* $ARB: E 9 SETXMITENABLE */
  372.  
  373. /* $ARB: B 10 SETINPUTGAIN */
  374. void rx_setinputgain( struct RexxHost *host, struct rxd_setinputgain **rxd, long action, struct RexxMsg *rexxmsg )
  375. {
  376.     struct rxd_setinputgain *rd = *rxd;
  377.  
  378.     switch( action )
  379.     {
  380.         case RXIF_INIT:
  381.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  382.             if( rd = *rxd )
  383.             {
  384.                 /* set your DEFAULTS here */
  385.             }
  386.             break;
  387.             
  388.         case RXIF_ACTION:
  389.             /* Insert your CODE here */
  390.             rd->rc = 0;
  391.             if (rd->arg.gain)
  392.             {
  393.                 UNLESS(rd->arg.relative) nLineGainValue = 0;
  394.                 RaiseLineGain(*rd->arg.gain);
  395.                 rd->rc = 1;
  396.             }
  397.             break;
  398.         
  399.         case RXIF_FREE:
  400.             /* FREE your local data here */
  401.             FreeVec( rd );
  402.             break;
  403.     }
  404.     return;
  405. }
  406. /* $ARB: E 10 SETINPUTGAIN */
  407.  
  408. /* $ARB: B 11 SETINPUTAMPLIFY */
  409. void rx_setinputamplify( struct RexxHost *host, struct rxd_setinputamplify **rxd, long action, struct RexxMsg *rexxmsg )
  410. {
  411.     struct rxd_setinputamplify *rd = *rxd;
  412.  
  413.     switch( action )
  414.     {
  415.         case RXIF_INIT:
  416.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  417.             if( rd = *rxd )
  418.             {
  419.                 /* set your DEFAULTS here */
  420.             }
  421.             break;
  422.             
  423.         case RXIF_ACTION:
  424.             /* Insert your CODE here */
  425.             rd->rc = 1;
  426.             if (rd->arg.multiplier) 
  427.             {
  428.                 switch(*rd->arg.multiplier)
  429.                 {
  430.                     case 1: nAmpShift = IntData.ulShiftLeft = 0; break;
  431.                     case 2: nAmpShift = IntData.ulShiftLeft = 1; break;
  432.                     case 4: nAmpShift = IntData.ulShiftLeft = 2; break;
  433.                     default: rd->rc = 0;
  434.                 }
  435.             } else rd->rc = 0;
  436.             break;
  437.         
  438.         case RXIF_FREE:
  439.             /* FREE your local data here */
  440.             FreeVec( rd );
  441.             break;
  442.     }
  443.     return;
  444. }
  445. /* $ARB: E 11 SETINPUTAMPLIFY */
  446.  
  447. /* $ARB: B 12 SETINPUTCHANNEL */
  448. void rx_setinputchannel( struct RexxHost *host, struct rxd_setinputchannel **rxd, long action, struct RexxMsg *rexxmsg )
  449. {
  450.     struct rxd_setinputchannel *rd = *rxd;
  451.  
  452.     switch( action )
  453.     {
  454.         case RXIF_INIT:
  455.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  456.             if( rd = *rxd )
  457.             {
  458.                 /* set your DEFAULTS here */
  459.             }
  460.             break;
  461.             
  462.         case RXIF_ACTION:
  463.             /* Insert your CODE here */
  464.             if (rd->arg.left)  ChangeInputChannel(INPUT_JACK_LEFT);
  465.             if (rd->arg.right) ChangeInputChannel(INPUT_JACK_RIGHT);
  466.             rd->rc = (rd->arg.left || rd->arg.right);
  467.             break;
  468.         
  469.         case RXIF_FREE:
  470.             /* FREE your local data here */
  471.             FreeVec( rd );
  472.             break;
  473.     }
  474.     return;
  475. }
  476. /* $ARB: E 12 SETINPUTCHANNEL */
  477.  
  478. /* $ARB: B 14 SETENABLEONCONNECT */
  479. void rx_setenableonconnect( struct RexxHost *host, struct rxd_setenableonconnect **rxd, long action, struct RexxMsg *rexxmsg )
  480. {
  481.     struct rxd_setenableonconnect *rd = *rxd;
  482.  
  483.     switch( action )
  484.     {
  485.         case RXIF_INIT:
  486.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  487.             if( rd = *rxd )
  488.             {
  489.                 /* set your DEFAULTS here */
  490.             }
  491.             break;
  492.             
  493.         case RXIF_ACTION:
  494.             /* Insert your CODE here */
  495.             if (rd->arg.on)  BEnableOnConnect = TRUE; 
  496.             if (rd->arg.off) BEnableOnConnect = FALSE;
  497.             rd->rc = (rd->arg.on || rd->arg.off);
  498.             break;
  499.         
  500.         case RXIF_FREE:
  501.             /* FREE your local data here */
  502.             FreeVec( rd );
  503.             break;
  504.     }
  505.     return;
  506. }
  507. /* $ARB: E 14 SETENABLEONCONNECT */
  508.  
  509. /* $ARB: B 15 SETINPUTSOURCE */
  510. void rx_setinputsource( struct RexxHost *host, struct rxd_setinputsource **rxd, long action, struct RexxMsg *rexxmsg )
  511. {
  512.     struct rxd_setinputsource *rd = *rxd;
  513.  
  514.     switch( action )
  515.     {
  516.         case RXIF_INIT:
  517.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  518.             if( rd = *rxd )
  519.             {
  520.                 /* set your DEFAULTS here */
  521.             }
  522.             break;
  523.             
  524.         case RXIF_ACTION:
  525.             /* Insert your CODE here */
  526.             if (rd->arg.mic)  ChangeInputSource(INPUT_SOURCE_MIC, TRUE);
  527.             if (rd->arg.line) ChangeInputSource(INPUT_SOURCE_EXT, TRUE);
  528.             rd->rc = (rd->arg.mic || rd->arg.line);
  529.             break;
  530.         
  531.         case RXIF_FREE:
  532.             /* FREE your local data here */
  533.             FreeVec( rd );
  534.             break;
  535.     }
  536.     return;
  537. }
  538. /* $ARB: E 15 SETINPUTSOURCE */
  539.  
  540. /* $ARB: B 16 SETXMITONPLAY */
  541. void rx_setxmitonplay( struct RexxHost *host, struct rxd_setxmitonplay **rxd, long action, struct RexxMsg *rexxmsg )
  542. {
  543.     struct rxd_setxmitonplay *rd = *rxd;
  544.  
  545.     switch( action )
  546.     {
  547.         case RXIF_INIT:
  548.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  549.             if( rd = *rxd )
  550.             {
  551.                 /* set your DEFAULTS here */
  552.             }
  553.             break;
  554.             
  555.         case RXIF_ACTION:
  556.             /* Insert your CODE here */
  557.             if (rd->arg.on)  BXmitOnPlay = TRUE; 
  558.             if (rd->arg.off) BXmitOnPlay = FALSE;
  559.             rd->rc = (rd->arg.on || rd->arg.off);
  560.             break;
  561.         
  562.         case RXIF_FREE:
  563.             /* FREE your local data here */
  564.             FreeVec( rd );
  565.             break;
  566.     }
  567.     return;
  568. }
  569. /* $ARB: E 16 SETXMITONPLAY */
  570.  
  571. /* $ARB: B 17 SETTCPBATCHXMIT */
  572. void rx_settcpbatchxmit( struct RexxHost *host, struct rxd_settcpbatchxmit **rxd, long action, struct RexxMsg *rexxmsg )
  573. {
  574.     struct rxd_settcpbatchxmit *rd = *rxd;
  575.  
  576.     switch( action )
  577.     {
  578.         case RXIF_INIT:
  579.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  580.             if( rd = *rxd )
  581.             {
  582.                 /* set your DEFAULTS here */
  583.             }
  584.             break;
  585.             
  586.         case RXIF_ACTION:
  587.             /* Insert your CODE here */            
  588.             if (rd->arg.on)  BTCPBatchXmit = TRUE; 
  589.             if (rd->arg.off) BTCPBatchXmit = FALSE;
  590.             rd->rc = (rd->arg.on || rd->arg.off);
  591.  
  592.             break;
  593.         
  594.         case RXIF_FREE:
  595.             /* FREE your local data here */
  596.             FreeVec( rd );
  597.             break;
  598.     }
  599.     return;
  600. }
  601. /* $ARB: E 17 SETTCPBATCHXMIT */
  602.  
  603. /* $ARB: B 18 SETSAMPLERATE */
  604. void rx_setsamplerate( struct RexxHost *host, struct rxd_setsamplerate **rxd, long action, struct RexxMsg *rexxmsg )
  605. {
  606.     struct rxd_setsamplerate *rd = *rxd;
  607.  
  608.     switch( action )
  609.     {
  610.         case RXIF_INIT:
  611.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  612.             if( rd = *rxd )
  613.             {
  614.                 /* set your DEFAULTS here */
  615.             }
  616.             break;
  617.             
  618.         case RXIF_ACTION:
  619.             /* Insert your CODE here */
  620.             if (rd->arg.rate)
  621.             {
  622.                 FakeIDCMPMessage(IDCMP_GADGETUP, *rd->arg.rate, FREQ_SLIDER);
  623.                 rd->rc = 1;
  624.             } else rd->rc = 0;
  625.             break;
  626.         
  627.         case RXIF_FREE:
  628.             /* FREE your local data here */
  629.             FreeVec( rd );
  630.             break;
  631.     }
  632.     return;
  633. }
  634. /* $ARB: E 18 SETSAMPLERATE */
  635.  
  636. /* $ARB: B 19 SETXMITDELAY */
  637. void rx_setxmitdelay( struct RexxHost *host, struct rxd_setxmitdelay **rxd, long action, struct RexxMsg *rexxmsg )
  638. {
  639.     struct rxd_setxmitdelay *rd = *rxd;
  640.  
  641.     switch( action )
  642.     {
  643.         case RXIF_INIT:
  644.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  645.             if( rd = *rxd )
  646.             {
  647.                 /* set your DEFAULTS here */
  648.             }
  649.             break;
  650.             
  651.         case RXIF_ACTION:
  652.             /* Insert your CODE here */
  653.             if (rd->arg.milliseconds)
  654.             {
  655.                 FakeIDCMPMessage(IDCMP_GADGETUP, *rd->arg.milliseconds, DELAY_SLIDER);
  656.                 rd->rc = 1;
  657.             } else rd->rc = 0;
  658.             break;
  659.         
  660.         case RXIF_FREE:
  661.             /* FREE your local data here */
  662.             FreeVec( rd );
  663.             break;
  664.     }
  665.     return;
  666. }
  667. /* $ARB: E 19 SETXMITDELAY */
  668.  
  669. /* $ARB: B 20 SETTHRESHVOL */
  670. void rx_setthreshvol( struct RexxHost *host, struct rxd_setthreshvol **rxd, long action, struct RexxMsg *rexxmsg )
  671. {
  672.     struct rxd_setthreshvol *rd = *rxd;
  673.  
  674.     switch( action )
  675.     {
  676.         case RXIF_INIT:
  677.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  678.             if( rd = *rxd )
  679.             {
  680.                 /* set your DEFAULTS here */
  681.             }
  682.             break;
  683.             
  684.         case RXIF_ACTION:
  685.             /* Insert your CODE here */
  686.             if (rd->arg.threshold)
  687.             {
  688.                 ChangeVolumeThreshold(*rd->arg.threshold);
  689.                 rd->rc = 1;
  690.             } else rd->rc = 0;
  691.             break;
  692.         
  693.         case RXIF_FREE:
  694.             /* FREE your local data here */
  695.             FreeVec( rd );
  696.             break;
  697.     }
  698.     return;
  699. }
  700. /* $ARB: E 20 SETTHRESHVOL */
  701.  
  702. /* $ARB: B 21 ENABLE */
  703. void rx_enable( struct RexxHost *host, struct rxd_enable **rxd, long action, struct RexxMsg *rexxmsg )
  704. {
  705.     struct rxd_enable *rd = *rxd;
  706.  
  707.     switch( action )
  708.     {
  709.         case RXIF_INIT:
  710.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  711.             break;
  712.             
  713.         case RXIF_ACTION:
  714.             /* Insert your CODE here */
  715.             ToggleMicButton(CODE_ON);
  716.             rd->rc = BTransmitting;
  717.             break;
  718.         
  719.         case RXIF_FREE:
  720.             /* FREE your local data here */
  721.             FreeVec( rd );
  722.             break;
  723.     }
  724.     return;
  725. }
  726. /* $ARB: E 21 ENABLE */
  727.  
  728. /* $ARB: B 22 DISABLE */
  729. void rx_disable( struct RexxHost *host, struct rxd_disable **rxd, long action, struct RexxMsg *rexxmsg )
  730. {
  731.     struct rxd_disable *rd = *rxd;
  732.  
  733.     switch( action )
  734.     {
  735.         case RXIF_INIT:
  736.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  737.             break;
  738.             
  739.         case RXIF_ACTION:
  740.             /* Insert your CODE here */
  741.             ToggleMicButton(CODE_OFF);
  742.             rd->rc = (BTransmitting == FALSE);
  743.             break;
  744.         
  745.         case RXIF_FREE:
  746.             /* FREE your local data here */
  747.             FreeVec( rd );
  748.             break;
  749.     }
  750.     return;
  751. }
  752. /* $ARB: E 22 DISABLE */
  753.  
  754. /* $ARB: B 23 GETSTATE */
  755. void rx_getstate( struct RexxHost *host, struct rxd_getstate **rxd, long action, struct RexxMsg *rexxmsg )
  756. {
  757.     struct rxd_getstate *rd = *rxd;
  758.     static char szResRemoteName[MAXPEERNAMELENGTH];
  759.     static char szResSamplerState[15];
  760.     static char szResChannel[6];
  761.     static char szResSampler[20];
  762.     static char szResCompression[15];
  763.     static char szResSource[6];
  764.     static char szResXmitenable[7];
  765.     static LONG ulResversion, ulResmemo, ulResxmitenable, ulResinputgain, 
  766.             ulResamplify, ulResenableonconnect, ulResxmitonplay,
  767.                 ulRestcpbatchxmit, ulRessamplerate, ulResxmitdelay,
  768.             ulResthreshvol, ulResbrowseropen, ulResfilereqopen,
  769.             ulReszoomed;
  770.  
  771.     switch( action )
  772.     {
  773.         case RXIF_INIT:
  774.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  775.             break;
  776.             
  777.         case RXIF_ACTION:
  778.             /* Insert your CODE here */
  779.             if (BNetConnect) Strncpy(szResRemoteName, szPeerName, sizeof(szResRemoteName));
  780.                     else strcpy(szResRemoteName, "(Not connected)");
  781.                     rd->res.remotename = szResRemoteName;
  782.       
  783.               /* Just use the regular string */              
  784.                     rd->res.voicemaildir = szVoiceMailDir;
  785.                     
  786.                     GetSamplerState(szResSamplerState);
  787.                     rd->res.samplerstate = szResSamplerState;
  788.  
  789.                     rd->res.lastmemofile = szLastMemoFile;
  790.  
  791.                  if (ubInputChannel == INPUT_JACK_LEFT)  strcpy(szResChannel,"LEFT");
  792.             else if (ubInputChannel == INPUT_JACK_RIGHT) strcpy(szResChannel,"RIGHT");
  793.             else strcpy(szResChannel, "????");
  794.                     rd->res.inputchannel = szResChannel;
  795.  
  796.                  if (ubInputSource == INPUT_SOURCE_MIC) strcpy(szResSource,"MIC");
  797.             else if (ubInputSource == INPUT_SOURCE_EXT) strcpy(szResSource,"LINE");
  798.             else strcpy(szResSource, "????");
  799.                     rd->res.inputsource = szResSource;
  800.  
  801.             GetSamplerType(szResSampler, ubSamplerType);
  802.                     rd->res.sampler = szResSampler;
  803.                     
  804.                          if (ubCurrComp == COMPRESS_ADPCM2) strcpy(szResCompression,"ADPCM2");
  805.                     else if (ubCurrComp == COMPRESS_ADPCM3) strcpy(szResCompression,"ADPCM3");
  806.                     else if (ubCurrComp == COMPRESS_NONE)   strcpy(szResCompression,"NONE");
  807.                     rd->res.compression = szResCompression;
  808.  
  809.                  if (nToggleMode == TOGGLE_TOGGLE) strcpy(szResXmitenable, "TOGGLE");
  810.             else if (nToggleMode == TOGGLE_HOLD)   strcpy(szResXmitenable, "HOLD");
  811.             else strcpy(szResXmitenable, "????");
  812.             rd->res.xmitenable = szResXmitenable;
  813.             
  814.             /* A little hackery here--otherwise memos make AmiPhone look like it's sending */
  815.             UNLESS(BNetConnect) {ulRexxSendAve = ulRexxReceiveAve = 0L;}
  816.             
  817.             ulResversion         = VERSION_NUMBER;    rd->res.version        = &ulResversion;
  818.                     ulResmemo        = (fpMemo != NULL);    rd->res.memo        = &ulResmemo;
  819.                     ulResinputgain        = nLineGainValue;    rd->res.inputgain    = &ulResinputgain;
  820.                     ulResamplify        = 1<<nAmpShift;        rd->res.amplify        = &ulResamplify;
  821.                     ulResenableonconnect     = BEnableOnConnect;    rd->res.enableonconnect    = &ulResenableonconnect;
  822.                     ulResxmitonplay        = BXmitOnPlay;        rd->res.xmitonplay    = &ulResxmitonplay;
  823.                     ulRestcpbatchxmit    = BTCPBatchXmit;    rd->res.tcpbatchxmit    = &ulRestcpbatchxmit;
  824.                     ulRessamplerate        = ulBytesPerSecond;    rd->res.samplerate    = &ulRessamplerate;
  825.                     ulResxmitdelay        = (fPacketDelay * 1000);rd->res.xmitdelay    = &ulResxmitdelay;
  826.                     ulResthreshvol        = nMinSampleVol;    rd->res.threshvol    = &ulResthreshvol;
  827.                     ulResbrowseropen    = BBrowserIsRunning;    rd->res.browseropen    = &ulResbrowseropen;
  828.                     ulResfilereqopen    = (FileReqTask != NULL);rd->res.filereqopen    = &ulResfilereqopen;
  829.                     ulReszoomed        = BZoomed;        rd->res.zoomed        = &ulReszoomed;
  830.                                             rd->res.receiverate     = &ulRexxReceiveAve;
  831.                                             rd->res.sendrate      = &ulRexxSendAve;
  832.             break;
  833.         
  834.         case RXIF_FREE:
  835.             /* FREE your local data here */
  836.             FreeVec( rd );
  837.             break;
  838.     }
  839.     return;
  840. }
  841. /* $ARB: E 23 GETSTATE */
  842.  
  843. /* $ARB: B 24 BROWSER */
  844. void rx_browser( struct RexxHost *host, struct rxd_browser **rxd, long action, struct RexxMsg *rexxmsg )
  845. {
  846.     struct rxd_browser *rd = *rxd;
  847.  
  848.     switch( action )
  849.     {
  850.         case RXIF_INIT:
  851.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  852.             if( rd = *rxd )
  853.             {
  854.                 /* set your DEFAULTS here */
  855.             }
  856.             break;
  857.             
  858.         case RXIF_ACTION:
  859.             /* Insert your CODE here */
  860.             if ((rd->arg.show)&&(BBrowserIsRunning == FALSE)&&(*szVoiceMailDir != '\0'))
  861.             {
  862.                 StartBrowser(szVoiceMailDir);
  863.                 rd->rc = 1;
  864.             }
  865.             else if ((rd->arg.hide)&&(BBrowserIsRunning == TRUE))
  866.             {
  867.                 StopBrowser();
  868.                 rd->rc = 1;
  869.             } else rd->rc = 0;
  870.             break;
  871.         
  872.         case RXIF_FREE:
  873.             /* FREE your local data here */
  874.             FreeVec( rd );
  875.             break;
  876.     }
  877.     return;
  878. }
  879. /* $ARB: E 24 BROWSER */
  880.  
  881. /* $ARB: B 25 DAEMON */
  882. void rx_daemon( struct RexxHost *host, struct rxd_daemon **rxd, long action, struct RexxMsg *rexxmsg )
  883. {
  884.     struct rxd_daemon *rd = *rxd;
  885.  
  886.     switch( action )
  887.     {
  888.         case RXIF_INIT:
  889.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  890.             if( rd = *rxd )
  891.             {
  892.                 /* set your DEFAULTS here */
  893.             }
  894.             break;
  895.             
  896.         case RXIF_ACTION:
  897.             /* Insert your CODE here */
  898.             if (((rd->arg.show)&&(daemonInfo->BWindowIsOpen == FALSE)) ||
  899.                  ((rd->arg.hide)&&(daemonInfo->BWindowIsOpen == TRUE)))
  900.              {
  901.                  FakeIDCMPMessage(IDCMP_MENUPICK, T_SHOWDAEMON, 0);
  902.                  rd->rc = 1;
  903.             } rd->rc = 0;
  904.             break;
  905.         
  906.         case RXIF_FREE:
  907.             /* FREE your local data here */
  908.             FreeVec( rd );
  909.             break;
  910.     }
  911.     return;
  912. }
  913. /* $ARB: E 25 DAEMON */
  914.  
  915. /* $ARB: B 26 ZOOM */
  916. void rx_zoom( struct RexxHost *host, struct rxd_zoom **rxd, long action, struct RexxMsg *rexxmsg )
  917. {
  918.     struct rxd_zoom *rd = *rxd;
  919.  
  920.     switch( action )
  921.     {
  922.         case RXIF_INIT:
  923.             *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  924.             if( rd = *rxd )
  925.             {
  926.                 /* set your DEFAULTS here */
  927.             }
  928.             break;
  929.             
  930.         case RXIF_ACTION:
  931.             /* Insert your CODE here */
  932.             if (((rd->arg.big)&&(BZoomed == TRUE)) ||
  933.                 ((rd->arg.small)&&(BZoomed == FALSE)))
  934.             {
  935.                 ZipWindow(PhoneWindow);
  936.                 rd->rc = 1;
  937.             }
  938.             else rd->rc = 0;
  939.             break;
  940.         
  941.         case RXIF_FREE:
  942.             /* FREE your local data here */
  943.             FreeVec( rd );
  944.             break;
  945.     }
  946.     return;
  947. }
  948. /* $ARB: E 26 ZOOM */
  949.  
  950.  
  951. #ifndef RX_ALIAS_C
  952. char *ExpandRXCommand( struct RexxHost *host, char *command )
  953. {
  954.     /* Insert your ALIAS-HANDLER here */
  955.     return( NULL );
  956. }
  957. #endif
  958.  
  959.